// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.shein.order.goods;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SheinOrderGoods;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SheinOrderGoods.class)
@Setter
@Getter
public class SheinOrderGoodsSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SheinOrderGoods".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 订单号(模糊搜索)
   */
  private String orderNo;

  /**
   * 订单号 比较(eq)
   */
  private String orderNoEq;
  /**
   * 订单号 比较(neq)
   */
  private String orderNoNeq;
  /**
   * 订单号 比较(gt)
   */
  private String orderNoGt;
  /**
   * 订单号 比较(gte)
   */
  private String orderNoGte;
  /**
   * 订单号 比较(lt)
   */
  private String orderNoLt;
  /**
   * 订单号 比较(lte)
   */
  private String orderNoLte;
  /**
   * 订单号 比较(contains)
   */
  private String orderNoContains;
  /**
   * 订单号 比较(notcontains)
   */
  private String orderNoNotcontains;
  /**
   * 订单号 比较(startswith)
   */
  private String orderNoStartswith;
  /**
   * 订单号 比较(endswith)
   */
  private String orderNoEndswith;
  /**
   * 订单号 比较(isnull)
   */
  private Boolean orderNoIsnull;
  /**
   * 订单号 比较(isnotnull)
   */
  private Boolean orderNoIsnotnull;

  /**
   * 订单号(精确搜索)
   */
  private List<String> orderNoInList;

  /**
   * 商品编号(模糊搜索)
   */
  private String goodsId;

  /**
   * 商品编号 比较(eq)
   */
  private String goodsIdEq;
  /**
   * 商品编号 比较(neq)
   */
  private String goodsIdNeq;
  /**
   * 商品编号 比较(gt)
   */
  private String goodsIdGt;
  /**
   * 商品编号 比较(gte)
   */
  private String goodsIdGte;
  /**
   * 商品编号 比较(lt)
   */
  private String goodsIdLt;
  /**
   * 商品编号 比较(lte)
   */
  private String goodsIdLte;
  /**
   * 商品编号 比较(contains)
   */
  private String goodsIdContains;
  /**
   * 商品编号 比较(notcontains)
   */
  private String goodsIdNotcontains;
  /**
   * 商品编号 比较(startswith)
   */
  private String goodsIdStartswith;
  /**
   * 商品编号 比较(endswith)
   */
  private String goodsIdEndswith;
  /**
   * 商品编号 比较(isnull)
   */
  private Boolean goodsIdIsnull;
  /**
   * 商品编号 比较(isnotnull)
   */
  private Boolean goodsIdIsnotnull;

  /**
   * 商品编号(精确搜索)
   */
  private List<String> goodsIdInList;

  /**
   * SKU(模糊搜索)
   */
  private String skuCode;

  /**
   * SKU 比较(eq)
   */
  private String skuCodeEq;
  /**
   * SKU 比较(neq)
   */
  private String skuCodeNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuCodeGt;
  /**
   * SKU 比较(gte)
   */
  private String skuCodeGte;
  /**
   * SKU 比较(lt)
   */
  private String skuCodeLt;
  /**
   * SKU 比较(lte)
   */
  private String skuCodeLte;
  /**
   * SKU 比较(contains)
   */
  private String skuCodeContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuCodeNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuCodeStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuCodeEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuCodeIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuCodeIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuCodeInList;

  /**
   * SKC(模糊搜索)
   */
  private String skc;

  /**
   * SKC 比较(eq)
   */
  private String skcEq;
  /**
   * SKC 比较(neq)
   */
  private String skcNeq;
  /**
   * SKC 比较(gt)
   */
  private String skcGt;
  /**
   * SKC 比较(gte)
   */
  private String skcGte;
  /**
   * SKC 比较(lt)
   */
  private String skcLt;
  /**
   * SKC 比较(lte)
   */
  private String skcLte;
  /**
   * SKC 比较(contains)
   */
  private String skcContains;
  /**
   * SKC 比较(notcontains)
   */
  private String skcNotcontains;
  /**
   * SKC 比较(startswith)
   */
  private String skcStartswith;
  /**
   * SKC 比较(endswith)
   */
  private String skcEndswith;
  /**
   * SKC 比较(isnull)
   */
  private Boolean skcIsnull;
  /**
   * SKC 比较(isnotnull)
   */
  private Boolean skcIsnotnull;

  /**
   * SKC(精确搜索)
   */
  private List<String> skcInList;

  /**
   * 卖方SPU的ID(模糊搜索)
   */
  private String goodsSn;

  /**
   * 卖方SPU的ID 比较(eq)
   */
  private String goodsSnEq;
  /**
   * 卖方SPU的ID 比较(neq)
   */
  private String goodsSnNeq;
  /**
   * 卖方SPU的ID 比较(gt)
   */
  private String goodsSnGt;
  /**
   * 卖方SPU的ID 比较(gte)
   */
  private String goodsSnGte;
  /**
   * 卖方SPU的ID 比较(lt)
   */
  private String goodsSnLt;
  /**
   * 卖方SPU的ID 比较(lte)
   */
  private String goodsSnLte;
  /**
   * 卖方SPU的ID 比较(contains)
   */
  private String goodsSnContains;
  /**
   * 卖方SPU的ID 比较(notcontains)
   */
  private String goodsSnNotcontains;
  /**
   * 卖方SPU的ID 比较(startswith)
   */
  private String goodsSnStartswith;
  /**
   * 卖方SPU的ID 比较(endswith)
   */
  private String goodsSnEndswith;
  /**
   * 卖方SPU的ID 比较(isnull)
   */
  private Boolean goodsSnIsnull;
  /**
   * 卖方SPU的ID 比较(isnotnull)
   */
  private Boolean goodsSnIsnotnull;

  /**
   * 卖方SPU的ID(精确搜索)
   */
  private List<String> goodsSnInList;

  /**
   * 卖方SKU(模糊搜索)
   */
  private String sellerSku;

  /**
   * 卖方SKU 比较(eq)
   */
  private String sellerSkuEq;
  /**
   * 卖方SKU 比较(neq)
   */
  private String sellerSkuNeq;
  /**
   * 卖方SKU 比较(gt)
   */
  private String sellerSkuGt;
  /**
   * 卖方SKU 比较(gte)
   */
  private String sellerSkuGte;
  /**
   * 卖方SKU 比较(lt)
   */
  private String sellerSkuLt;
  /**
   * 卖方SKU 比较(lte)
   */
  private String sellerSkuLte;
  /**
   * 卖方SKU 比较(contains)
   */
  private String sellerSkuContains;
  /**
   * 卖方SKU 比较(notcontains)
   */
  private String sellerSkuNotcontains;
  /**
   * 卖方SKU 比较(startswith)
   */
  private String sellerSkuStartswith;
  /**
   * 卖方SKU 比较(endswith)
   */
  private String sellerSkuEndswith;
  /**
   * 卖方SKU 比较(isnull)
   */
  private Boolean sellerSkuIsnull;
  /**
   * 卖方SKU 比较(isnotnull)
   */
  private Boolean sellerSkuIsnotnull;

  /**
   * 卖方SKU(精确搜索)
   */
  private List<String> sellerSkuInList;

  /**
   * 商品状态(模糊搜索)
   */
  private String goodsStatus;

  /**
   * 商品状态 比较(eq)
   */
  private String goodsStatusEq;
  /**
   * 商品状态 比较(neq)
   */
  private String goodsStatusNeq;
  /**
   * 商品状态 比较(gt)
   */
  private String goodsStatusGt;
  /**
   * 商品状态 比较(gte)
   */
  private String goodsStatusGte;
  /**
   * 商品状态 比较(lt)
   */
  private String goodsStatusLt;
  /**
   * 商品状态 比较(lte)
   */
  private String goodsStatusLte;
  /**
   * 商品状态 比较(contains)
   */
  private String goodsStatusContains;
  /**
   * 商品状态 比较(notcontains)
   */
  private String goodsStatusNotcontains;
  /**
   * 商品状态 比较(startswith)
   */
  private String goodsStatusStartswith;
  /**
   * 商品状态 比较(endswith)
   */
  private String goodsStatusEndswith;
  /**
   * 商品状态 比较(isnull)
   */
  private Boolean goodsStatusIsnull;
  /**
   * 商品状态 比较(isnotnull)
   */
  private Boolean goodsStatusIsnotnull;

  /**
   * 商品状态(精确搜索)
   */
  private List<String> goodsStatusInList;

  /**
   * 订单货物状态(模糊搜索)
   */
  private String newGoodsStatus;

  /**
   * 订单货物状态 比较(eq)
   */
  private String newGoodsStatusEq;
  /**
   * 订单货物状态 比较(neq)
   */
  private String newGoodsStatusNeq;
  /**
   * 订单货物状态 比较(gt)
   */
  private String newGoodsStatusGt;
  /**
   * 订单货物状态 比较(gte)
   */
  private String newGoodsStatusGte;
  /**
   * 订单货物状态 比较(lt)
   */
  private String newGoodsStatusLt;
  /**
   * 订单货物状态 比较(lte)
   */
  private String newGoodsStatusLte;
  /**
   * 订单货物状态 比较(contains)
   */
  private String newGoodsStatusContains;
  /**
   * 订单货物状态 比较(notcontains)
   */
  private String newGoodsStatusNotcontains;
  /**
   * 订单货物状态 比较(startswith)
   */
  private String newGoodsStatusStartswith;
  /**
   * 订单货物状态 比较(endswith)
   */
  private String newGoodsStatusEndswith;
  /**
   * 订单货物状态 比较(isnull)
   */
  private Boolean newGoodsStatusIsnull;
  /**
   * 订单货物状态 比较(isnotnull)
   */
  private Boolean newGoodsStatusIsnotnull;

  /**
   * 订单货物状态(精确搜索)
   */
  private List<String> newGoodsStatusInList;

  /**
   * SKU属性信息(模糊搜索)
   */
  private String skuAttribute;

  /**
   * SKU属性信息 比较(eq)
   */
  private String skuAttributeEq;
  /**
   * SKU属性信息 比较(neq)
   */
  private String skuAttributeNeq;
  /**
   * SKU属性信息 比较(gt)
   */
  private String skuAttributeGt;
  /**
   * SKU属性信息 比较(gte)
   */
  private String skuAttributeGte;
  /**
   * SKU属性信息 比较(lt)
   */
  private String skuAttributeLt;
  /**
   * SKU属性信息 比较(lte)
   */
  private String skuAttributeLte;
  /**
   * SKU属性信息 比较(contains)
   */
  private String skuAttributeContains;
  /**
   * SKU属性信息 比较(notcontains)
   */
  private String skuAttributeNotcontains;
  /**
   * SKU属性信息 比较(startswith)
   */
  private String skuAttributeStartswith;
  /**
   * SKU属性信息 比较(endswith)
   */
  private String skuAttributeEndswith;
  /**
   * SKU属性信息 比较(isnull)
   */
  private Boolean skuAttributeIsnull;
  /**
   * SKU属性信息 比较(isnotnull)
   */
  private Boolean skuAttributeIsnotnull;

  /**
   * 产品名称(模糊搜索)
   */
  private String goodsTitle;

  /**
   * 产品名称 比较(eq)
   */
  private String goodsTitleEq;
  /**
   * 产品名称 比较(neq)
   */
  private String goodsTitleNeq;
  /**
   * 产品名称 比较(gt)
   */
  private String goodsTitleGt;
  /**
   * 产品名称 比较(gte)
   */
  private String goodsTitleGte;
  /**
   * 产品名称 比较(lt)
   */
  private String goodsTitleLt;
  /**
   * 产品名称 比较(lte)
   */
  private String goodsTitleLte;
  /**
   * 产品名称 比较(contains)
   */
  private String goodsTitleContains;
  /**
   * 产品名称 比较(notcontains)
   */
  private String goodsTitleNotcontains;
  /**
   * 产品名称 比较(startswith)
   */
  private String goodsTitleStartswith;
  /**
   * 产品名称 比较(endswith)
   */
  private String goodsTitleEndswith;
  /**
   * 产品名称 比较(isnull)
   */
  private Boolean goodsTitleIsnull;
  /**
   * 产品名称 比较(isnotnull)
   */
  private Boolean goodsTitleIsnotnull;

  /**
   * 产品图片地址(模糊搜索)
   */
  private String spuPicURL;

  /**
   * 产品图片地址 比较(eq)
   */
  private String spuPicURLEq;
  /**
   * 产品图片地址 比较(neq)
   */
  private String spuPicURLNeq;
  /**
   * 产品图片地址 比较(gt)
   */
  private String spuPicURLGt;
  /**
   * 产品图片地址 比较(gte)
   */
  private String spuPicURLGte;
  /**
   * 产品图片地址 比较(lt)
   */
  private String spuPicURLLt;
  /**
   * 产品图片地址 比较(lte)
   */
  private String spuPicURLLte;
  /**
   * 产品图片地址 比较(contains)
   */
  private String spuPicURLContains;
  /**
   * 产品图片地址 比较(notcontains)
   */
  private String spuPicURLNotcontains;
  /**
   * 产品图片地址 比较(startswith)
   */
  private String spuPicURLStartswith;
  /**
   * 产品图片地址 比较(endswith)
   */
  private String spuPicURLEndswith;
  /**
   * 产品图片地址 比较(isnull)
   */
  private Boolean spuPicURLIsnull;
  /**
   * 产品图片地址 比较(isnotnull)
   */
  private Boolean spuPicURLIsnotnull;

  /**
   * 商品重量
   */
  private java.math.BigDecimal goodsWeight;

  /**
   * 最小商品重量
   */
  private java.math.BigDecimal goodsWeightMin;

  /**
   * 最大商品重量
   */
  private java.math.BigDecimal goodsWeightMax;

  /**
   * 商品重量 比较(eq)
   */
  private java.math.BigDecimal goodsWeightEq;
  /**
   * 商品重量 比较(neq)
   */
  private java.math.BigDecimal goodsWeightNeq;
  /**
   * 商品重量 比较(gt)
   */
  private java.math.BigDecimal goodsWeightGt;
  /**
   * 商品重量 比较(gte)
   */
  private java.math.BigDecimal goodsWeightGte;
  /**
   * 商品重量 比较(lt)
   */
  private java.math.BigDecimal goodsWeightLt;
  /**
   * 商品重量 比较(lte)
   */
  private java.math.BigDecimal goodsWeightLte;
  /**
   * 商品重量 比较(contains)
   */
  private java.math.BigDecimal goodsWeightContains;
  /**
   * 商品重量 比较(notcontains)
   */
  private java.math.BigDecimal goodsWeightNotcontains;
  /**
   * 商品重量 比较(startswith)
   */
  private java.math.BigDecimal goodsWeightStartswith;
  /**
   * 商品重量 比较(endswith)
   */
  private java.math.BigDecimal goodsWeightEndswith;
  /**
   * 商品重量 比较(isnull)
   */
  private Boolean goodsWeightIsnull;
  /**
   * 商品重量 比较(isnotnull)
   */
  private Boolean goodsWeightIsnotnull;

  /**
   * 库存标签
   */
  private String storageTag;

  /**
   * 库存标签 比较(eq)
   */
  private String storageTagEq;
  /**
   * 库存标签 比较(neq)
   */
  private String storageTagNeq;
  /**
   * 库存标签 比较(gt)
   */
  private String storageTagGt;
  /**
   * 库存标签 比较(gte)
   */
  private String storageTagGte;
  /**
   * 库存标签 比较(lt)
   */
  private String storageTagLt;
  /**
   * 库存标签 比较(lte)
   */
  private String storageTagLte;
  /**
   * 库存标签 比较(contains)
   */
  private String storageTagContains;
  /**
   * 库存标签 比较(notcontains)
   */
  private String storageTagNotcontains;
  /**
   * 库存标签 比较(startswith)
   */
  private String storageTagStartswith;
  /**
   * 库存标签 比较(endswith)
   */
  private String storageTagEndswith;
  /**
   * 库存标签 比较(isnull)
   */
  private Boolean storageTagIsnull;
  /**
   * 库存标签 比较(isnotnull)
   */
  private Boolean storageTagIsnotnull;

  /**
   * 库存标签(精确搜索)
   */
  private List<String> storageTagInList;

  /**
   * 物流状态
   */
  private String performanceTag;

  /**
   * 物流状态 比较(eq)
   */
  private String performanceTagEq;
  /**
   * 物流状态 比较(neq)
   */
  private String performanceTagNeq;
  /**
   * 物流状态 比较(gt)
   */
  private String performanceTagGt;
  /**
   * 物流状态 比较(gte)
   */
  private String performanceTagGte;
  /**
   * 物流状态 比较(lt)
   */
  private String performanceTagLt;
  /**
   * 物流状态 比较(lte)
   */
  private String performanceTagLte;
  /**
   * 物流状态 比较(contains)
   */
  private String performanceTagContains;
  /**
   * 物流状态 比较(notcontains)
   */
  private String performanceTagNotcontains;
  /**
   * 物流状态 比较(startswith)
   */
  private String performanceTagStartswith;
  /**
   * 物流状态 比较(endswith)
   */
  private String performanceTagEndswith;
  /**
   * 物流状态 比较(isnull)
   */
  private Boolean performanceTagIsnull;
  /**
   * 物流状态 比较(isnotnull)
   */
  private Boolean performanceTagIsnotnull;

  /**
   * 物流状态(精确搜索)
   */
  private List<String> performanceTagInList;

  /**
   * 换货标示
   */
  private String goodsExchangeTag;

  /**
   * 换货标示 比较(eq)
   */
  private String goodsExchangeTagEq;
  /**
   * 换货标示 比较(neq)
   */
  private String goodsExchangeTagNeq;
  /**
   * 换货标示 比较(gt)
   */
  private String goodsExchangeTagGt;
  /**
   * 换货标示 比较(gte)
   */
  private String goodsExchangeTagGte;
  /**
   * 换货标示 比较(lt)
   */
  private String goodsExchangeTagLt;
  /**
   * 换货标示 比较(lte)
   */
  private String goodsExchangeTagLte;
  /**
   * 换货标示 比较(contains)
   */
  private String goodsExchangeTagContains;
  /**
   * 换货标示 比较(notcontains)
   */
  private String goodsExchangeTagNotcontains;
  /**
   * 换货标示 比较(startswith)
   */
  private String goodsExchangeTagStartswith;
  /**
   * 换货标示 比较(endswith)
   */
  private String goodsExchangeTagEndswith;
  /**
   * 换货标示 比较(isnull)
   */
  private Boolean goodsExchangeTagIsnull;
  /**
   * 换货标示 比较(isnotnull)
   */
  private Boolean goodsExchangeTagIsnotnull;

  /**
   * 换货标示(精确搜索)
   */
  private List<String> goodsExchangeTagInList;

  /**
   * 被交换产品的id(模糊搜索)
   */
  private String beExchangeEntityId;

  /**
   * 被交换产品的id 比较(eq)
   */
  private String beExchangeEntityIdEq;
  /**
   * 被交换产品的id 比较(neq)
   */
  private String beExchangeEntityIdNeq;
  /**
   * 被交换产品的id 比较(gt)
   */
  private String beExchangeEntityIdGt;
  /**
   * 被交换产品的id 比较(gte)
   */
  private String beExchangeEntityIdGte;
  /**
   * 被交换产品的id 比较(lt)
   */
  private String beExchangeEntityIdLt;
  /**
   * 被交换产品的id 比较(lte)
   */
  private String beExchangeEntityIdLte;
  /**
   * 被交换产品的id 比较(contains)
   */
  private String beExchangeEntityIdContains;
  /**
   * 被交换产品的id 比较(notcontains)
   */
  private String beExchangeEntityIdNotcontains;
  /**
   * 被交换产品的id 比较(startswith)
   */
  private String beExchangeEntityIdStartswith;
  /**
   * 被交换产品的id 比较(endswith)
   */
  private String beExchangeEntityIdEndswith;
  /**
   * 被交换产品的id 比较(isnull)
   */
  private Boolean beExchangeEntityIdIsnull;
  /**
   * 被交换产品的id 比较(isnotnull)
   */
  private Boolean beExchangeEntityIdIsnotnull;

  /**
   * 被交换产品的id(精确搜索)
   */
  private List<String> beExchangeEntityIdInList;

  /**
   * 货币(模糊搜索)
   */
  private String orderCurrency;

  /**
   * 货币 比较(eq)
   */
  private String orderCurrencyEq;
  /**
   * 货币 比较(neq)
   */
  private String orderCurrencyNeq;
  /**
   * 货币 比较(gt)
   */
  private String orderCurrencyGt;
  /**
   * 货币 比较(gte)
   */
  private String orderCurrencyGte;
  /**
   * 货币 比较(lt)
   */
  private String orderCurrencyLt;
  /**
   * 货币 比较(lte)
   */
  private String orderCurrencyLte;
  /**
   * 货币 比较(contains)
   */
  private String orderCurrencyContains;
  /**
   * 货币 比较(notcontains)
   */
  private String orderCurrencyNotcontains;
  /**
   * 货币 比较(startswith)
   */
  private String orderCurrencyStartswith;
  /**
   * 货币 比较(endswith)
   */
  private String orderCurrencyEndswith;
  /**
   * 货币 比较(isnull)
   */
  private Boolean orderCurrencyIsnull;
  /**
   * 货币 比较(isnotnull)
   */
  private Boolean orderCurrencyIsnotnull;

  /**
   * 货币(精确搜索)
   */
  private List<String> orderCurrencyInList;

  /**
   * 订单货物销售价格
   */
  private java.math.BigDecimal sellerCurrencyPrice;

  /**
   * 最小订单货物销售价格
   */
  private java.math.BigDecimal sellerCurrencyPriceMin;

  /**
   * 最大订单货物销售价格
   */
  private java.math.BigDecimal sellerCurrencyPriceMax;

  /**
   * 订单货物销售价格 比较(eq)
   */
  private java.math.BigDecimal sellerCurrencyPriceEq;
  /**
   * 订单货物销售价格 比较(neq)
   */
  private java.math.BigDecimal sellerCurrencyPriceNeq;
  /**
   * 订单货物销售价格 比较(gt)
   */
  private java.math.BigDecimal sellerCurrencyPriceGt;
  /**
   * 订单货物销售价格 比较(gte)
   */
  private java.math.BigDecimal sellerCurrencyPriceGte;
  /**
   * 订单货物销售价格 比较(lt)
   */
  private java.math.BigDecimal sellerCurrencyPriceLt;
  /**
   * 订单货物销售价格 比较(lte)
   */
  private java.math.BigDecimal sellerCurrencyPriceLte;
  /**
   * 订单货物销售价格 比较(contains)
   */
  private java.math.BigDecimal sellerCurrencyPriceContains;
  /**
   * 订单货物销售价格 比较(notcontains)
   */
  private java.math.BigDecimal sellerCurrencyPriceNotcontains;
  /**
   * 订单货物销售价格 比较(startswith)
   */
  private java.math.BigDecimal sellerCurrencyPriceStartswith;
  /**
   * 订单货物销售价格 比较(endswith)
   */
  private java.math.BigDecimal sellerCurrencyPriceEndswith;
  /**
   * 订单货物销售价格 比较(isnull)
   */
  private Boolean sellerCurrencyPriceIsnull;
  /**
   * 订单货物销售价格 比较(isnotnull)
   */
  private Boolean sellerCurrencyPriceIsnotnull;

  /**
   * 店内优惠券金额
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPrice;

  /**
   * 最小店内优惠券金额
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceMin;

  /**
   * 最大店内优惠券金额
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceMax;

  /**
   * 店内优惠券金额 比较(eq)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceEq;
  /**
   * 店内优惠券金额 比较(neq)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceNeq;
  /**
   * 店内优惠券金额 比较(gt)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceGt;
  /**
   * 店内优惠券金额 比较(gte)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceGte;
  /**
   * 店内优惠券金额 比较(lt)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceLt;
  /**
   * 店内优惠券金额 比较(lte)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceLte;
  /**
   * 店内优惠券金额 比较(contains)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceContains;
  /**
   * 店内优惠券金额 比较(notcontains)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceNotcontains;
  /**
   * 店内优惠券金额 比较(startswith)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceStartswith;
  /**
   * 店内优惠券金额 比较(endswith)
   */
  private java.math.BigDecimal orderCurrencyStoreCouponPriceEndswith;
  /**
   * 店内优惠券金额 比较(isnull)
   */
  private Boolean orderCurrencyStoreCouponPriceIsnull;
  /**
   * 店内优惠券金额 比较(isnotnull)
   */
  private Boolean orderCurrencyStoreCouponPriceIsnotnull;

  /**
   * 促销折扣金额
   */
  private java.math.BigDecimal orderCurrencyPromotionPrice;

  /**
   * 最小促销折扣金额
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceMin;

  /**
   * 最大促销折扣金额
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceMax;

  /**
   * 促销折扣金额 比较(eq)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceEq;
  /**
   * 促销折扣金额 比较(neq)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceNeq;
  /**
   * 促销折扣金额 比较(gt)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceGt;
  /**
   * 促销折扣金额 比较(gte)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceGte;
  /**
   * 促销折扣金额 比较(lt)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceLt;
  /**
   * 促销折扣金额 比较(lte)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceLte;
  /**
   * 促销折扣金额 比较(contains)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceContains;
  /**
   * 促销折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceNotcontains;
  /**
   * 促销折扣金额 比较(startswith)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceStartswith;
  /**
   * 促销折扣金额 比较(endswith)
   */
  private java.math.BigDecimal orderCurrencyPromotionPriceEndswith;
  /**
   * 促销折扣金额 比较(isnull)
   */
  private Boolean orderCurrencyPromotionPriceIsnull;
  /**
   * 促销折扣金额 比较(isnotnull)
   */
  private Boolean orderCurrencyPromotionPriceIsnotnull;

  /**
   * SHEIN向卖家收取的佣金
   */
  private java.math.BigDecimal commission;

  /**
   * 最小SHEIN向卖家收取的佣金
   */
  private java.math.BigDecimal commissionMin;

  /**
   * 最大SHEIN向卖家收取的佣金
   */
  private java.math.BigDecimal commissionMax;

  /**
   * SHEIN向卖家收取的佣金 比较(eq)
   */
  private java.math.BigDecimal commissionEq;
  /**
   * SHEIN向卖家收取的佣金 比较(neq)
   */
  private java.math.BigDecimal commissionNeq;
  /**
   * SHEIN向卖家收取的佣金 比较(gt)
   */
  private java.math.BigDecimal commissionGt;
  /**
   * SHEIN向卖家收取的佣金 比较(gte)
   */
  private java.math.BigDecimal commissionGte;
  /**
   * SHEIN向卖家收取的佣金 比较(lt)
   */
  private java.math.BigDecimal commissionLt;
  /**
   * SHEIN向卖家收取的佣金 比较(lte)
   */
  private java.math.BigDecimal commissionLte;
  /**
   * SHEIN向卖家收取的佣金 比较(contains)
   */
  private java.math.BigDecimal commissionContains;
  /**
   * SHEIN向卖家收取的佣金 比较(notcontains)
   */
  private java.math.BigDecimal commissionNotcontains;
  /**
   * SHEIN向卖家收取的佣金 比较(startswith)
   */
  private java.math.BigDecimal commissionStartswith;
  /**
   * SHEIN向卖家收取的佣金 比较(endswith)
   */
  private java.math.BigDecimal commissionEndswith;
  /**
   * SHEIN向卖家收取的佣金 比较(isnull)
   */
  private Boolean commissionIsnull;
  /**
   * SHEIN向卖家收取的佣金 比较(isnotnull)
   */
  private Boolean commissionIsnotnull;

  /**
   * 佣金费率
   */
  private java.math.BigDecimal commissionRate;

  /**
   * 最小佣金费率
   */
  private java.math.BigDecimal commissionRateMin;

  /**
   * 最大佣金费率
   */
  private java.math.BigDecimal commissionRateMax;

  /**
   * 佣金费率 比较(eq)
   */
  private java.math.BigDecimal commissionRateEq;
  /**
   * 佣金费率 比较(neq)
   */
  private java.math.BigDecimal commissionRateNeq;
  /**
   * 佣金费率 比较(gt)
   */
  private java.math.BigDecimal commissionRateGt;
  /**
   * 佣金费率 比较(gte)
   */
  private java.math.BigDecimal commissionRateGte;
  /**
   * 佣金费率 比较(lt)
   */
  private java.math.BigDecimal commissionRateLt;
  /**
   * 佣金费率 比较(lte)
   */
  private java.math.BigDecimal commissionRateLte;
  /**
   * 佣金费率 比较(contains)
   */
  private java.math.BigDecimal commissionRateContains;
  /**
   * 佣金费率 比较(notcontains)
   */
  private java.math.BigDecimal commissionRateNotcontains;
  /**
   * 佣金费率 比较(startswith)
   */
  private java.math.BigDecimal commissionRateStartswith;
  /**
   * 佣金费率 比较(endswith)
   */
  private java.math.BigDecimal commissionRateEndswith;
  /**
   * 佣金费率 比较(isnull)
   */
  private Boolean commissionRateIsnull;
  /**
   * 佣金费率 比较(isnotnull)
   */
  private Boolean commissionRateIsnotnull;

  /**
   * SHEIN向SFS卖家收取的服务费
   */
  private java.math.BigDecimal serviceCharge;

  /**
   * 最小SHEIN向SFS卖家收取的服务费
   */
  private java.math.BigDecimal serviceChargeMin;

  /**
   * 最大SHEIN向SFS卖家收取的服务费
   */
  private java.math.BigDecimal serviceChargeMax;

  /**
   * SHEIN向SFS卖家收取的服务费 比较(eq)
   */
  private java.math.BigDecimal serviceChargeEq;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(neq)
   */
  private java.math.BigDecimal serviceChargeNeq;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(gt)
   */
  private java.math.BigDecimal serviceChargeGt;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(gte)
   */
  private java.math.BigDecimal serviceChargeGte;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(lt)
   */
  private java.math.BigDecimal serviceChargeLt;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(lte)
   */
  private java.math.BigDecimal serviceChargeLte;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(contains)
   */
  private java.math.BigDecimal serviceChargeContains;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(notcontains)
   */
  private java.math.BigDecimal serviceChargeNotcontains;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(startswith)
   */
  private java.math.BigDecimal serviceChargeStartswith;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(endswith)
   */
  private java.math.BigDecimal serviceChargeEndswith;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(isnull)
   */
  private Boolean serviceChargeIsnull;
  /**
   * SHEIN向SFS卖家收取的服务费 比较(isnotnull)
   */
  private Boolean serviceChargeIsnotnull;

  /**
   * SHEIN向卖家收取的履约服务费
   */
  private java.math.BigDecimal performanceServiceCharge;

  /**
   * 最小SHEIN向卖家收取的履约服务费
   */
  private java.math.BigDecimal performanceServiceChargeMin;

  /**
   * 最大SHEIN向卖家收取的履约服务费
   */
  private java.math.BigDecimal performanceServiceChargeMax;

  /**
   * SHEIN向卖家收取的履约服务费 比较(eq)
   */
  private java.math.BigDecimal performanceServiceChargeEq;
  /**
   * SHEIN向卖家收取的履约服务费 比较(neq)
   */
  private java.math.BigDecimal performanceServiceChargeNeq;
  /**
   * SHEIN向卖家收取的履约服务费 比较(gt)
   */
  private java.math.BigDecimal performanceServiceChargeGt;
  /**
   * SHEIN向卖家收取的履约服务费 比较(gte)
   */
  private java.math.BigDecimal performanceServiceChargeGte;
  /**
   * SHEIN向卖家收取的履约服务费 比较(lt)
   */
  private java.math.BigDecimal performanceServiceChargeLt;
  /**
   * SHEIN向卖家收取的履约服务费 比较(lte)
   */
  private java.math.BigDecimal performanceServiceChargeLte;
  /**
   * SHEIN向卖家收取的履约服务费 比较(contains)
   */
  private java.math.BigDecimal performanceServiceChargeContains;
  /**
   * SHEIN向卖家收取的履约服务费 比较(notcontains)
   */
  private java.math.BigDecimal performanceServiceChargeNotcontains;
  /**
   * SHEIN向卖家收取的履约服务费 比较(startswith)
   */
  private java.math.BigDecimal performanceServiceChargeStartswith;
  /**
   * SHEIN向卖家收取的履约服务费 比较(endswith)
   */
  private java.math.BigDecimal performanceServiceChargeEndswith;
  /**
   * SHEIN向卖家收取的履约服务费 比较(isnull)
   */
  private Boolean performanceServiceChargeIsnull;
  /**
   * SHEIN向卖家收取的履约服务费 比较(isnotnull)
   */
  private Boolean performanceServiceChargeIsnotnull;

  /**
   * 预估收入
   */
  private java.math.BigDecimal estimatedIncome;

  /**
   * 最小预估收入
   */
  private java.math.BigDecimal estimatedIncomeMin;

  /**
   * 最大预估收入
   */
  private java.math.BigDecimal estimatedIncomeMax;

  /**
   * 预估收入 比较(eq)
   */
  private java.math.BigDecimal estimatedIncomeEq;
  /**
   * 预估收入 比较(neq)
   */
  private java.math.BigDecimal estimatedIncomeNeq;
  /**
   * 预估收入 比较(gt)
   */
  private java.math.BigDecimal estimatedIncomeGt;
  /**
   * 预估收入 比较(gte)
   */
  private java.math.BigDecimal estimatedIncomeGte;
  /**
   * 预估收入 比较(lt)
   */
  private java.math.BigDecimal estimatedIncomeLt;
  /**
   * 预估收入 比较(lte)
   */
  private java.math.BigDecimal estimatedIncomeLte;
  /**
   * 预估收入 比较(contains)
   */
  private java.math.BigDecimal estimatedIncomeContains;
  /**
   * 预估收入 比较(notcontains)
   */
  private java.math.BigDecimal estimatedIncomeNotcontains;
  /**
   * 预估收入 比较(startswith)
   */
  private java.math.BigDecimal estimatedIncomeStartswith;
  /**
   * 预估收入 比较(endswith)
   */
  private java.math.BigDecimal estimatedIncomeEndswith;
  /**
   * 预估收入 比较(isnull)
   */
  private Boolean estimatedIncomeIsnull;
  /**
   * 预估收入 比较(isnotnull)
   */
  private Boolean estimatedIncomeIsnotnull;

  /**
   * SPU(模糊搜索)
   */
  private String spuName;

  /**
   * SPU 比较(eq)
   */
  private String spuNameEq;
  /**
   * SPU 比较(neq)
   */
  private String spuNameNeq;
  /**
   * SPU 比较(gt)
   */
  private String spuNameGt;
  /**
   * SPU 比较(gte)
   */
  private String spuNameGte;
  /**
   * SPU 比较(lt)
   */
  private String spuNameLt;
  /**
   * SPU 比较(lte)
   */
  private String spuNameLte;
  /**
   * SPU 比较(contains)
   */
  private String spuNameContains;
  /**
   * SPU 比较(notcontains)
   */
  private String spuNameNotcontains;
  /**
   * SPU 比较(startswith)
   */
  private String spuNameStartswith;
  /**
   * SPU 比较(endswith)
   */
  private String spuNameEndswith;
  /**
   * SPU 比较(isnull)
   */
  private Boolean spuNameIsnull;
  /**
   * SPU 比较(isnotnull)
   */
  private Boolean spuNameIsnotnull;

  /**
   * SPU(精确搜索)
   */
  private List<String> spuNameInList;

  /**
   * 货物销售税
   */
  private java.math.BigDecimal saleTax;

  /**
   * 最小货物销售税
   */
  private java.math.BigDecimal saleTaxMin;

  /**
   * 最大货物销售税
   */
  private java.math.BigDecimal saleTaxMax;

  /**
   * 货物销售税 比较(eq)
   */
  private java.math.BigDecimal saleTaxEq;
  /**
   * 货物销售税 比较(neq)
   */
  private java.math.BigDecimal saleTaxNeq;
  /**
   * 货物销售税 比较(gt)
   */
  private java.math.BigDecimal saleTaxGt;
  /**
   * 货物销售税 比较(gte)
   */
  private java.math.BigDecimal saleTaxGte;
  /**
   * 货物销售税 比较(lt)
   */
  private java.math.BigDecimal saleTaxLt;
  /**
   * 货物销售税 比较(lte)
   */
  private java.math.BigDecimal saleTaxLte;
  /**
   * 货物销售税 比较(contains)
   */
  private java.math.BigDecimal saleTaxContains;
  /**
   * 货物销售税 比较(notcontains)
   */
  private java.math.BigDecimal saleTaxNotcontains;
  /**
   * 货物销售税 比较(startswith)
   */
  private java.math.BigDecimal saleTaxStartswith;
  /**
   * 货物销售税 比较(endswith)
   */
  private java.math.BigDecimal saleTaxEndswith;
  /**
   * 货物销售税 比较(isnull)
   */
  private Boolean saleTaxIsnull;
  /**
   * 货物销售税 比较(isnotnull)
   */
  private Boolean saleTaxIsnotnull;

  /**
   * 仓库编号(模糊搜索)
   */
  private String warehouseCode;

  /**
   * 仓库编号 比较(eq)
   */
  private String warehouseCodeEq;
  /**
   * 仓库编号 比较(neq)
   */
  private String warehouseCodeNeq;
  /**
   * 仓库编号 比较(gt)
   */
  private String warehouseCodeGt;
  /**
   * 仓库编号 比较(gte)
   */
  private String warehouseCodeGte;
  /**
   * 仓库编号 比较(lt)
   */
  private String warehouseCodeLt;
  /**
   * 仓库编号 比较(lte)
   */
  private String warehouseCodeLte;
  /**
   * 仓库编号 比较(contains)
   */
  private String warehouseCodeContains;
  /**
   * 仓库编号 比较(notcontains)
   */
  private String warehouseCodeNotcontains;
  /**
   * 仓库编号 比较(startswith)
   */
  private String warehouseCodeStartswith;
  /**
   * 仓库编号 比较(endswith)
   */
  private String warehouseCodeEndswith;
  /**
   * 仓库编号 比较(isnull)
   */
  private Boolean warehouseCodeIsnull;
  /**
   * 仓库编号 比较(isnotnull)
   */
  private Boolean warehouseCodeIsnotnull;

  /**
   * 仓库编号(精确搜索)
   */
  private List<String> warehouseCodeInList;

  /**
   * 仓库名(模糊搜索)
   */
  private String warehouseName;

  /**
   * 仓库名 比较(eq)
   */
  private String warehouseNameEq;
  /**
   * 仓库名 比较(neq)
   */
  private String warehouseNameNeq;
  /**
   * 仓库名 比较(gt)
   */
  private String warehouseNameGt;
  /**
   * 仓库名 比较(gte)
   */
  private String warehouseNameGte;
  /**
   * 仓库名 比较(lt)
   */
  private String warehouseNameLt;
  /**
   * 仓库名 比较(lte)
   */
  private String warehouseNameLte;
  /**
   * 仓库名 比较(contains)
   */
  private String warehouseNameContains;
  /**
   * 仓库名 比较(notcontains)
   */
  private String warehouseNameNotcontains;
  /**
   * 仓库名 比较(startswith)
   */
  private String warehouseNameStartswith;
  /**
   * 仓库名 比较(endswith)
   */
  private String warehouseNameEndswith;
  /**
   * 仓库名 比较(isnull)
   */
  private Boolean warehouseNameIsnull;
  /**
   * 仓库名 比较(isnotnull)
   */
  private Boolean warehouseNameIsnotnull;

  /**
   * 仓库名(精确搜索)
   */
  private List<String> warehouseNameInList;

  /**
   * 卖方货币折扣价
   */
  private java.math.BigDecimal sellerCurrencyDiscountPrice;

  /**
   * 最小卖方货币折扣价
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceMin;

  /**
   * 最大卖方货币折扣价
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceMax;

  /**
   * 卖方货币折扣价 比较(eq)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceEq;
  /**
   * 卖方货币折扣价 比较(neq)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceNeq;
  /**
   * 卖方货币折扣价 比较(gt)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceGt;
  /**
   * 卖方货币折扣价 比较(gte)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceGte;
  /**
   * 卖方货币折扣价 比较(lt)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceLt;
  /**
   * 卖方货币折扣价 比较(lte)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceLte;
  /**
   * 卖方货币折扣价 比较(contains)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceContains;
  /**
   * 卖方货币折扣价 比较(notcontains)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceNotcontains;
  /**
   * 卖方货币折扣价 比较(startswith)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceStartswith;
  /**
   * 卖方货币折扣价 比较(endswith)
   */
  private java.math.BigDecimal sellerCurrencyDiscountPriceEndswith;
  /**
   * 卖方货币折扣价 比较(isnull)
   */
  private Boolean sellerCurrencyDiscountPriceIsnull;
  /**
   * 卖方货币折扣价 比较(isnotnull)
   */
  private Boolean sellerCurrencyDiscountPriceIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
